package com.beantools.util;

import com.beantools.execption.InformationException;

import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import static com.beantools.util.StringUtil.isBlank;

/**
 * 这是一个排序工具类。
 *
 * @author baoya
 * @version 1.1.0
 * @since 1.0
 */

public class SortUtil {

    /**
     * 这是按照降序排序的方法
     *
     * @param keyValues 待排序的容器
     * @return 返回的是按照降序排序后的值
     */
    public static List<String> descSort(Set<String> keyValues) {
        return sort(keyValues, false);
    }

    /**
     * 这是按照升序排序的方法
     *
     * @param keyValues 待排序的容器
     * @return 返回的是按照升序排序后的值
     */
    public static List<String> ascSort(Set<String> keyValues) {
        return sort(keyValues, true);
    }

    /**
     * 这是一个排序方法。有一个签名原串的容器，比如
     * <pre>
     *    keyValues.add(english=WEDNESDAY)
     *    keyValues.add(chinese=星期三)
     * </pre>
     * 按照字母的顺序排序，有可能是升序，也有可能是降序
     *
     * @param keyValues 待排序的容器
     * @param isAsc     true 升序  false 降序
     * @return 返回的是按照一定格式排序的值
     */
    public static List<String> sort(Set<String> keyValues, boolean isAsc) {
        if (CollectionUtil.isEmpty(keyValues)) {
            return null;
        }
        List<String> keyList = new LinkedList<>(keyValues);
        for (int i = 0; i < keyList.size() - 1; i++) {
            for (int j = 0; j < keyList.size() - (i + 1); j++) {
                KeysUtil keysUtil = new KeysUtil(keyList, j).invoke();
                String currKey = keysUtil.getCurrKey();
                String afterKey = keysUtil.getAfterKey();
                char[] currKeyChars = keysUtil.getCurrKeyChars();
                for (int k = 0; k < currKeyChars.length; k++) {
                    //保证当前字符是有效字符，即在26个字母之中,不在，直接放到后面
                    if (CharUtil.validateLetter(currKeyChars[k])) {
                        // 小于，不用排序，直接跳出
                        if (currKeyChars[k] < afterKey.charAt(k)) {
                            if (isAsc) {
                                break;
                            } else {
                                if (CharUtil.validateLetter(afterKey.charAt(k))) {
                                    keyList.set(j, afterKey);
                                    keyList.set(j + 1, currKey);
                                }
                            }
                            //  等于，跳过此循环
                        } else if (currKeyChars[k] == afterKey.charAt(k)) {
                            continue;
                            //  大于，看清而定
                        } else {
                            if (isAsc) {
                                if (CharUtil.validateLetter(afterKey.charAt(k))) {
                                    keyList.set(j, afterKey);
                                    keyList.set(j + 1, currKey);
                                }
                            }
                            break;
                        }
                    } else {
                        if (isAsc) {
                            keyList.set(j, afterKey);
                            keyList.set(j + 1, currKey);
                        }
                        break;
                    }
                }
            }

        }
        return keyList;
    }

    /**
     * 根据整形数组进行排序，按照升序或者按照降序排
     *
     * @param locates 整形数组
     * @return 排序后的值
     */
    public static int[] sort(int[] locates) {
        if (locates.length <= 1) {
            return locates;
        }
        int len = locates.length;
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len - (i + 1); j++) {
                if (locates[j] > locates[j + 1]) {
                    int tmp = locates[j + 1];
                    locates[j + 1] = locates[j];
                    locates[j] = tmp;
                }
            }
        }
        return locates;
    }

    /**
     * 去除<code>int</code>数组中的重复数
     *
     * @param locates 整形数组
     * @return 排序后的值
     */
    public static Set<Integer> removeRepetitionAfterSort(int[] locates) {
        if (locates.length == 0) {
            throw new InformationException("数组为空或不存在");
        }
        locates = sort(locates);
        Set<Integer> set = new LinkedHashSet();
        for (int locate : locates) {
            set.add(locate);
        }
        return set;
    }


    /**
     * 使用嵌套类
     */
    private static class KeysUtil {

        /**
         * jsonObject的key值集合
         */
        private List<String> keyList;

        /**
         * 下标值
         */
        private int j;

        /**
         * 当前key值
         */
        private String currKey;

        /**
         * 下一个key值
         */
        private String afterKey;

        /**
         * 当前字符串key值的字符集
         */
        private char[] currKeyChars;

        public KeysUtil(List<String> keyList, int j) {
            this.keyList = keyList;
            this.j = j;
        }

        public String getCurrKey() {
            return currKey;
        }

        public String getAfterKey() {
            return afterKey;
        }

        public char[] getCurrKeyChars() {
            return currKeyChars;
        }

        public KeysUtil invoke() {
            currKey = keyList.get(j);
            afterKey = keyList.get(j + 1);
            if (isBlank(currKey) && isBlank(afterKey)) {
                throw new RuntimeException("当前值为空currKey=" + currKey + ",或者下一个值afterKey=" + afterKey);
            }
            currKeyChars = currKey.toCharArray();
            return this;
        }
    }
}
